home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / cplusinc / _string.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-18  |  34.9 KB  |  1,287 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Doug Lea (dl@rocky.oswego.edu)
  5.  
  6. This file is part of the GNU C++ Library.  This library is free
  7. software; you can redistribute it and/or modify it under the terms of
  8. the GNU Library General Public License as published by the Free
  9. Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.  This library is distributed in the hope
  11. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13. PURPOSE.  See the GNU Library General Public License for more details.
  14. You should have received a copy of the GNU Library General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18.  
  19.  
  20. #ifndef _String_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _String_h 1
  25.  
  26. #include <iostream.h>
  27. #ifndef __MSDOS__
  28. #include <Regex.h>
  29. #else
  30. #include <_Regex.h>
  31. #endif
  32.  
  33. struct StrRep                     // internal String representations
  34. {
  35.   unsigned short    len;         // string length 
  36.   unsigned short    sz;          // allocated space
  37.   char              s[1];        // the string starts here 
  38.                                  // (at least 1 char for trailing null)
  39.                                  // allocated & expanded via non-public fcts
  40. };
  41.  
  42. // primitive ops on StrReps -- nearly all String fns go through these.
  43.  
  44. StrRep*     Salloc(StrRep*, const char*, int, int);
  45. StrRep*     Scopy(StrRep*, const StrRep*);
  46. StrRep*     Scat(StrRep*, const char*, int, const char*, int);
  47. StrRep*     Scat(StrRep*, const char*, int,const char*,int, const char*,int);
  48. StrRep*     Sprepend(StrRep*, const char*, int);
  49. StrRep*     Sreverse(const StrRep*, StrRep*);
  50. StrRep*     Supcase(const StrRep*, StrRep*);
  51. StrRep*     Sdowncase(const StrRep*, StrRep*);
  52. StrRep*     Scapitalize(const StrRep*, StrRep*);
  53.  
  54. // These classes need to be defined in the order given
  55.  
  56. class String;
  57. class SubString;
  58.  
  59. class SubString
  60. {
  61.   friend class      String;
  62. protected:
  63.  
  64.   String&           S;        // The String I'm a substring of
  65.   unsigned short    pos;      // starting position in S's rep
  66.   unsigned short    len;      // length of substring
  67.  
  68.   void              assign(const StrRep*, const char*, int = -1);
  69.                     SubString(String& x, int p, int l);
  70.                     SubString(const SubString& x);
  71.  
  72. public:
  73.  
  74. // Note there are no public constructors. SubStrings are always
  75. // created via String operations
  76.  
  77.                    ~SubString();
  78.  
  79.   SubString&        operator =  (const String&     y);
  80.   SubString&        operator =  (const SubString&  y);
  81.   SubString&        operator =  (const char* t);
  82.   SubString&        operator =  (char        c);
  83.  
  84. // return 1 if target appears anywhere in SubString; else 0
  85.  
  86.   int               contains(char        c) const;
  87.   int               contains(const String&     y) const;
  88.   int               contains(const SubString&  y) const;
  89.   int               contains(const char* t) const;
  90.   int               contains(const Regex&       r) const;
  91.  
  92. // return 1 if target matches entire SubString
  93.  
  94.   int               matches(const Regex&  r) const;
  95.  
  96. // IO 
  97.  
  98.   friend ostream&   operator<<(ostream& s, const SubString& x);
  99.  
  100. // status
  101.  
  102.   unsigned int      length() const;
  103.   int               empty() const;
  104.   const char*       chars() const;
  105.  
  106.   int               OK() const; 
  107.  
  108. };
  109.  
  110.  
  111. class String
  112. {
  113.   friend class      SubString;
  114.  
  115. protected:
  116.   StrRep*           rep;   // Strings are pointers to their representations
  117.  
  118. // some helper functions
  119.  
  120.   int               search(int, int, const char*, int = -1) const;
  121.   int               search(int, int, char) const;
  122.   int               match(int, int, int, const char*, int = -1) const;
  123.   int               _gsub(const char*, int, const char* ,int);
  124.   int               _gsub(const Regex&, const char*, int);
  125.   SubString         _substr(int, int);
  126.  
  127. public:
  128.  
  129. // constructors & assignment
  130.  
  131.                     String();
  132.                     String(const String& x);
  133.                     String(const SubString&  x);
  134.                     String(const char* t);
  135.                     String(const char* t, int len);
  136.                     String(char c);
  137.  
  138.                     ~String();
  139.  
  140.   String&           operator =  (const String&     y);
  141.   String&           operator =  (const char* y);
  142.   String&           operator =  (char        c);
  143.   String&           operator =  (const SubString&  y);
  144.  
  145. // concatenation
  146.  
  147.   String&           operator += (const String&     y); 
  148.   String&           operator += (const SubString&  y);
  149.   String&           operator += (const char* t);
  150.   String&           operator += (char        c);
  151.  
  152.   void              prepend(const String&     y); 
  153.   void              prepend(const SubString&  y);
  154.   void              prepend(const char* t);
  155.   void              prepend(char        c);
  156.  
  157.  
  158. // procedural versions:
  159. // concatenate first 2 args, store result in last arg
  160.  
  161.   friend inline void     cat(const String&, const String&, String&);
  162.   friend inline void     cat(const String&, const SubString&, String&);
  163.   friend inline void     cat(const String&, const char*, String&);
  164.   friend inline void     cat(const String&, char, String&);
  165.  
  166.   friend inline void     cat(const SubString&, const String&, String&);
  167.   friend inline void     cat(const SubString&, const SubString&, String&);
  168.   friend inline void     cat(const SubString&, const char*, String&);
  169.   friend inline void     cat(const SubString&, char, String&);
  170.  
  171.   friend inline void     cat(const char*, const String&, String&);
  172.   friend inline void     cat(const char*, const SubString&, String&);
  173.   friend inline void     cat(const char*, const char*, String&);
  174.   friend inline void     cat(const char*, char, String&);
  175.  
  176. // double concatenation, by request. (yes, there are too many versions, 
  177. // but if one is supported, then the others should be too...)
  178. // Concatenate first 3 args, store in last arg
  179.  
  180.   friend inline void     cat(const String&,const String&, const String&,String&);
  181.   friend inline void     cat(const String&,const String&,const SubString&,String&);
  182.   friend inline void     cat(const String&,const String&, const char*, String&);
  183.   friend inline void     cat(const String&,const String&, char, String&);
  184.   friend inline void     cat(const String&,const SubString&,const String&,String&);
  185.   inline friend void     cat(const String&,const SubString&,const SubString&,String&);
  186.   friend inline void     cat(const String&,const SubString&, const char*, String&);
  187.   friend inline void     cat(const String&,const SubString&, char, String&);
  188.   friend inline void     cat(const String&,const char*, const String&,    String&);
  189.   friend inline void     cat(const String&,const char*, const SubString&, String&);
  190.   friend inline void     cat(const String&,const char*, const char*, String&);
  191.   friend inline void     cat(const String&,const char*, char, String&);
  192.  
  193.   friend inline void     cat(const char*, const String&, const String&,String&);
  194.   friend inline void     cat(const char*,const String&,const SubString&,String&);
  195.   friend inline void     cat(const char*,const String&, const char*, String&);
  196.   friend inline void     cat(const char*,const String&, char, String&);
  197.   friend inline void     cat(const char*,const SubString&,const String&,String&);
  198.   friend inline void     cat(const char*,const SubString&,const SubString&,String&);
  199.   friend inline void     cat(const char*,const SubString&, const char*, String&);
  200.   friend inline void     cat(const char*,const SubString&, char, String&);
  201.   friend inline void     cat(const char*,const char*, const String&,    String&);
  202.   friend inline void     cat(const char*,const char*, const SubString&, String&);
  203.   friend inline void     cat(const char*,const char*, const char*, String&);
  204.   friend inline void     cat(const char*,const char*, char, String&);
  205.  
  206.  
  207. // searching & matching
  208.  
  209. // return position of target in string or -1 for failure
  210.  
  211.   int               index(char        c, int startpos = 0) const;      
  212.   int               index(const String&     y, int startpos = 0) const;      
  213.   int               index(const SubString&  y, int startpos = 0) const;      
  214.   int               index(const char* t, int startpos = 0) const;  
  215.   int               index(const Regex&      r, int startpos = 0) const;       
  216.  
  217. // return 1 if target appears anyhere in String; else 0
  218.  
  219.   int               contains(char        c) const;
  220.   int               contains(const String&     y) const;
  221.   int               contains(const SubString&  y) const;
  222.   int               contains(const char* t) const;
  223.   int               contains(const Regex&      r) const;
  224.  
  225. // return 1 if target appears anywhere after position pos 
  226. // (or before, if pos is negative) in String; else 0
  227.  
  228.   int               contains(char        c, int pos) const;
  229.   int               contains(const String&     y, int pos) const;
  230.   int               contains(const SubString&  y, int pos) const;
  231.   int               contains(const char* t, int pos) const;
  232.   int               contains(const Regex&      r, int pos) const;
  233.  
  234. // return 1 if target appears at position pos in String; else 0
  235.  
  236.   int               matches(char        c, int pos = 0) const;
  237.   int               matches(const String&     y, int pos = 0) const;
  238.   int               matches(const SubString&  y, int pos = 0) const;
  239.   int               matches(const char* t, int pos = 0) const;
  240.   int               matches(const Regex&      r, int pos = 0) const;
  241.  
  242. //  return number of occurences of target in String
  243.  
  244.   int               freq(char        c) const; 
  245.   int               freq(const String&     y) const;
  246.   int               freq(const SubString&  y) const;
  247.   int               freq(const char* t) const;
  248.  
  249. // SubString extraction
  250.  
  251. // Note that you can't take a substring of a const String, since
  252. // this leaves open the possiblility of indirectly modifying the
  253. // String through the SubString
  254.  
  255.   SubString         at(int         pos, int len);
  256.   SubString         operator () (int         pos, int len); // synonym for at
  257.  
  258.   SubString         at(const String&     x, int startpos = 0); 
  259.   SubString         at(const SubString&  x, int startpos = 0); 
  260.   SubString         at(const char* t, int startpos = 0);
  261.   SubString         at(char        c, int startpos = 0);
  262.   SubString         at(const Regex&      r, int startpos = 0); 
  263.  
  264.   SubString         before(int          pos);
  265.   SubString         before(const String&      x, int startpos = 0);
  266.   SubString         before(const SubString&   x, int startpos = 0);
  267.   SubString         before(const char*  t, int startpos = 0);
  268.   SubString         before(char         c, int startpos = 0);
  269.   SubString         before(const Regex&       r, int startpos = 0);
  270.  
  271.   SubString         through(int          pos);
  272.   SubString         through(const String&      x, int startpos = 0);
  273.   SubString         through(const SubString&   x, int startpos = 0);
  274.   SubString         through(const char*  t, int startpos = 0);
  275.   SubString         through(char         c, int startpos = 0);
  276.   SubString         through(const Regex&       r, int startpos = 0);
  277.  
  278.   SubString         from(int          pos);
  279.   SubString         from(const String&      x, int startpos = 0);
  280.   SubString         from(const SubString&   x, int startpos = 0);
  281.   SubString         from(const char*  t, int startpos = 0);
  282.   SubString         from(char         c, int startpos = 0);
  283.   SubString         from(const Regex&       r, int startpos = 0);
  284.  
  285.   SubString         after(int         pos);
  286.   SubString         after(const String&     x, int startpos = 0);
  287.   SubString         after(const SubString&  x, int startpos = 0);
  288.   SubString         after(const char* t, int startpos = 0);
  289.   SubString         after(char        c, int startpos = 0);
  290.   SubString         after(const Regex&      r, int startpos = 0);
  291.  
  292.  
  293. // deletion
  294.  
  295. // delete len chars starting at pos
  296.   void              del(int         pos, int len);
  297.  
  298. // delete the first occurrence of target after startpos
  299.  
  300.   void              del(const String&     y, int startpos = 0);
  301.   void              del(const SubString&  y, int startpos = 0);
  302.   void              del(const char* t, int startpos = 0);
  303.   void              del(char        c, int startpos = 0);
  304.   void              del(const Regex&      r, int startpos = 0);
  305.  
  306. // global substitution: substitute all occurrences of pat with repl
  307.  
  308.   int               gsub(const String&     pat, const String&     repl);
  309.   int               gsub(const SubString&  pat, const String&     repl);
  310.   int               gsub(const char* pat, const String&     repl);
  311.   int               gsub(const char* pat, const char* repl);
  312.   int               gsub(const Regex&      pat, const String&     repl);
  313.  
  314. // friends & utilities
  315.  
  316. // split string into array res at separators; return number of elements
  317.  
  318.   friend int        split(const String& x, String res[], int maxn, 
  319.                           const String& sep);
  320.   friend int        split(const String& x, String res[], int maxn, 
  321.                           const Regex&  sep);
  322.  
  323.   friend String     common_prefix(const String& x, const String& y, 
  324.                                   int startpos = 0);
  325.   friend String     common_suffix(const String& x, const String& y, 
  326.                                   int startpos = -1);
  327.   friend String     replicate(char        c, int n);
  328.   friend String     replicate(const String&     y, int n);
  329.   friend String     join(String src[], int n, const String& sep);
  330.  
  331. // simple builtin transformations
  332.  
  333.   friend inline String     reverse(const String& x);
  334.   friend inline String     upcase(const String& x);
  335.   friend inline String     downcase(const String& x);
  336.   friend inline String     capitalize(const String& x);
  337.  
  338. // in-place versions of above
  339.  
  340.   void              reverse();
  341.   void              upcase();
  342.   void              downcase();
  343.   void              capitalize();
  344.  
  345. // element extraction
  346.  
  347.   char&             operator [] (int i);
  348.   const char&       operator [] (int i) const;
  349.   char              elem(int i) const;
  350.   char              firstchar() const;
  351.   char              lastchar() const;
  352.  
  353. // conversion
  354.  
  355.                     operator const char*() const;
  356.   const char*       chars() const;
  357.  
  358.  
  359. // IO
  360.  
  361.   friend inline ostream&   operator<<(ostream& s, const String& x);
  362.   friend ostream&   operator<<(ostream& s, const SubString& x);
  363.   friend istream&   operator>>(istream& s, String& x);
  364.  
  365.   friend int        readline(istream& s, String& x, 
  366.                              char terminator = '\n',
  367.                              int discard_terminator = 1);
  368.  
  369. // status
  370.  
  371.   unsigned int      length() const;
  372.   int               empty() const;
  373.  
  374. // preallocate some space for String
  375.   void              alloc(int newsize);
  376.  
  377. // report current allocation (not length!)
  378.  
  379.   int               allocation() const;
  380.  
  381.  
  382.   void     error(const char* msg) const;
  383.  
  384.   int               OK() const;
  385. };
  386.  
  387. typedef String StrTmp; // for backward compatibility
  388.  
  389. // other externs
  390.  
  391. int        compare(const String&    x, const String&     y);
  392. int        compare(const String&    x, const SubString&  y);
  393. int        compare(const String&    x, const char* y);
  394. int        compare(const SubString& x, const String&     y);
  395. int        compare(const SubString& x, const SubString&  y);
  396. int        compare(const SubString& x, const char* y);
  397. int        fcompare(const String&   x, const String&     y); // ignore case
  398.  
  399. extern StrRep  _nilStrRep;
  400. extern String _nilString;
  401.  
  402. // status reports, needed before defining other things
  403.  
  404. inline unsigned int String::length() const {  return rep->len; }
  405. inline int         String::empty() const { return rep->len == 0; }
  406. inline const char* String::chars() const { return &(rep->s[0]); }
  407. inline int         String::allocation() const { return rep->sz; }
  408.  
  409. inline unsigned int SubString::length() const { return len; }
  410. inline int         SubString::empty() const { return len == 0; }
  411. inline const char* SubString::chars() const { return &(S.rep->s[pos]); }
  412.  
  413.  
  414. // constructors
  415.  
  416. inline String::String() 
  417.   : rep(&_nilStrRep) {}
  418. inline String::String(const String& x) 
  419.   : rep(Scopy(0, x.rep)) {}
  420. inline String::String(const char* t) 
  421.   : rep(Salloc(0, t, -1, -1)) {}
  422. inline String::String(const char* t, int tlen)
  423.   : rep(Salloc(0, t, tlen, tlen)) {}
  424. inline String::String(const SubString& y)
  425.   : rep(Salloc(0, y.chars(), y.length(), y.length())) {}
  426. inline String::String(char c) 
  427.   : rep(Salloc(0, &c, 1, 1)) {}
  428.  
  429. inline String::~String() { if (rep != &_nilStrRep) delete rep; }
  430.  
  431. inline SubString::SubString(const SubString& x)
  432.   :S(x.S), pos(x.pos), len(x.len) {}
  433. inline SubString::SubString(String& x, int first, int l)
  434.   :S(x), pos(first), len(l) {}
  435.  
  436. inline SubString::~SubString() {}
  437.  
  438. // assignment
  439.  
  440. inline String& String::operator =  (const String& y)
  441. { 
  442.   rep = Scopy(rep, y.rep);
  443.   return *this;
  444. }
  445.  
  446. inline String& String::operator=(const char* t)
  447. {
  448.   rep = Salloc(rep, t, -1, -1);
  449.   return *this;
  450. }
  451.  
  452. inline String& String::operator=(const SubString&  y)
  453. {
  454.   rep = Salloc(rep, y.chars(), y.length(), y.length());
  455.   return *this;
  456. }
  457.  
  458. inline String& String::operator=(char c)
  459. {
  460.   rep = Salloc(rep, &c, 1, 1);
  461.   return *this;
  462. }
  463.  
  464.  
  465. inline SubString& SubString::operator = (const char* ys)
  466. {
  467.   assign(0, ys);
  468.   return *this;
  469. }
  470.  
  471. inline SubString& SubString::operator = (char ch)
  472. {
  473.   assign(0, &ch, 1);
  474.   return *this;
  475. }
  476.  
  477. inline SubString& SubString::operator = (const String& y)
  478. {
  479.   assign(y.rep, y.chars(), y.length());
  480.   return *this;
  481. }
  482.  
  483. inline SubString& SubString::operator = (const SubString& y)
  484. {
  485.   assign(y.S.rep, y.chars(), y.length());
  486.   return *this;
  487. }
  488.  
  489. // Zillions of cats...
  490.  
  491. inline void cat(const String& x, const String& y, String& r)
  492. {
  493.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  494. }
  495.  
  496. inline void cat(const String& x, const SubString& y, String& r)
  497. {
  498.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  499. }
  500.  
  501. inline void cat(const String& x, const char* y, String& r)
  502. {
  503.   r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
  504. }
  505.  
  506. inline void cat(const String& x, char y, String& r)
  507. {
  508.   r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
  509. }
  510.  
  511. inline void cat(const SubString& x, const String& y, String& r)
  512. {
  513.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  514. }
  515.  
  516. inline void cat(const SubString& x, const SubString& y, String& r)
  517. {
  518.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  519. }
  520.  
  521. inline void cat(const SubString& x, const char* y, String& r)
  522. {
  523.   r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
  524. }
  525.  
  526. inline void cat(const SubString& x, char y, String& r)
  527. {
  528.   r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
  529. }
  530.  
  531. inline void cat(const char* x, const String& y, String& r)
  532. {
  533.   r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
  534. }
  535.  
  536. inline void cat(const char* x, const SubString& y, String& r)
  537. {
  538.   r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
  539. }
  540.  
  541. inline void cat(const char* x, const char* y, String& r)
  542. {
  543.   r.rep = Scat(r.rep, x, -1, y, -1);
  544. }
  545.  
  546. inline void cat(const char* x, char y, String& r)
  547. {
  548.   r.rep = Scat(r.rep, x, -1, &y, 1);
  549. }
  550.  
  551. inline void cat(const String& a, const String& x, const String& y, String& r)
  552. {
  553.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  554. }
  555.  
  556. inline void cat(const String& a, const String& x, const SubString& y, String& r)
  557. {
  558.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  559. }
  560.  
  561. inline void cat(const String& a, const String& x, const char* y, String& r)
  562. {
  563.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
  564. }
  565.  
  566. inline void cat(const String& a, const String& x, char y, String& r)
  567. {
  568.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
  569. }
  570.  
  571. inline void cat(const String& a, const SubString& x, const String& y, String& r)
  572. {
  573.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  574. }
  575.  
  576. inline void cat(const String& a, const SubString& x, const SubString& y, String& r)
  577. {
  578.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  579. }
  580.  
  581. inline void cat(const String& a, const SubString& x, const char* y, String& r)
  582. {
  583.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
  584. }
  585.  
  586. inline void cat(const String& a, const SubString& x, char y, String& r)
  587. {
  588.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
  589. }
  590.  
  591. inline void cat(const String& a, const char* x, const String& y, String& r)
  592. {
  593.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
  594. }
  595.  
  596. inline void cat(const String& a, const char* x, const SubString& y, String& r)
  597. {
  598.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
  599. }
  600.  
  601. inline void cat(const String& a, const char* x, const char* y, String& r)
  602. {
  603.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y, -1);
  604. }
  605.  
  606. inline void cat(const String& a, const char* x, char y, String& r)
  607. {
  608.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, &y, 1);
  609. }
  610.  
  611.  
  612. inline void cat(const char* a, const String& x, const String& y, String& r)
  613. {
  614.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  615. }
  616.  
  617. inline void cat(const char* a, const String& x, const SubString& y, String& r)
  618. {
  619.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  620. }
  621.  
  622. inline void cat(const char* a, const String& x, const char* y, String& r)
  623. {
  624.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
  625. }
  626.  
  627. inline void cat(const char* a, const String& x, char y, String& r)
  628. {
  629.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
  630. }
  631.  
  632. inline void cat(const char* a, const SubString& x, const String& y, String& r)
  633. {
  634.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  635. }
  636.  
  637. inline void cat(const char* a, const SubString& x, const SubString& y, String& r)
  638. {
  639.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  640. }
  641.  
  642. inline void cat(const char* a, const SubString& x, const char* y, String& r)
  643. {
  644.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
  645. }
  646.  
  647. inline void cat(const char* a, const SubString& x, char y, String& r)
  648. {
  649.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
  650. }
  651.  
  652. inline void cat(const char* a, const char* x, const String& y, String& r)
  653. {
  654.   r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
  655. }
  656.  
  657. inline void cat(const char* a, const char* x, const SubString& y, String& r)
  658. {
  659.   r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
  660. }
  661.  
  662. inline void cat(const char* a, const char* x, const char* y, String& r)
  663. {
  664.   r.rep = Scat(r.rep, a, -1, x, -1, y, -1);
  665. }
  666.  
  667. inline void cat(const char* a, const char* x, char y, String& r)
  668. {
  669.   r.rep = Scat(r.rep, a, -1, x, -1, &y, 1);
  670. }
  671.  
  672.  
  673. // operator versions
  674.  
  675. inline String& String::operator +=(const String& y)
  676. {
  677.   cat(*this, y, *this);
  678.   return *this;
  679. }
  680.  
  681. inline String& String::operator +=(const SubString& y)
  682. {
  683.   cat(*this, y, *this);
  684.   return *this;
  685. }
  686.  
  687. inline String& String::operator += (const char* y)
  688. {
  689.   cat(*this, y, *this);
  690.   return *this;
  691. }
  692.  
  693. inline String& String:: operator +=(char y)
  694. {
  695.   cat(*this, y, *this);
  696.   return *this;
  697. }
  698.  
  699. // constructive concatenation
  700.  
  701. #if defined(__GNUG__) && !defined(_G_NO_NRV)
  702.  
  703. inline String operator + (const String& x, const String& y) return r;
  704. {
  705.   cat(x, y, r);
  706. }
  707.  
  708. inline String operator + (const String& x, const SubString& y) return r;
  709. {
  710.   cat(x, y, r);
  711. }
  712.  
  713. inline String operator + (const String& x, const char* y) return r;
  714. {
  715.   cat(x, y, r);
  716. }
  717.  
  718. inline String operator + (const String& x, char y) return r;
  719. {
  720.   cat(x, y, r);
  721. }
  722.  
  723. inline String operator + (const SubString& x, const String& y) return r;
  724. {
  725.   cat(x, y, r);
  726. }
  727.  
  728. inline String operator + (const SubString& x, const SubString& y) return r;
  729. {
  730.   cat(x, y, r);
  731. }
  732.  
  733. inline String operator + (const SubString& x, const char* y) return r;
  734. {
  735.   cat(x, y, r);
  736. }
  737.  
  738. inline String operator + (const SubString& x, char y) return r;
  739. {
  740.   cat(x, y, r);
  741. }
  742.  
  743. inline String operator + (const char* x, const String& y) return r;
  744. {
  745.   cat(x, y, r);
  746. }
  747.  
  748. inline String operator + (const char* x, const SubString& y) return r;
  749. {
  750.   cat(x, y, r);
  751. }
  752.  
  753. inline String reverse(const String& x) return r;
  754. {
  755.   r.rep = Sreverse(x.rep, r.rep);
  756. }
  757.  
  758. inline String upcase(const String& x) return r;
  759. {
  760.   r.rep = Supcase(x.rep, r.rep);
  761. }
  762.  
  763. inline String downcase(const String& x) return r;
  764. {
  765.   r.rep = Sdowncase(x.rep, r.rep);
  766. }
  767.  
  768. inline String capitalize(const String& x) return r;
  769. {
  770.   r.rep = Scapitalize(x.rep, r.rep);
  771. }
  772.  
  773. #else /* NO_NRV */
  774.  
  775. inline String operator + (const String& x, const String& y)
  776. {
  777.   String r;  cat(x, y, r);  return r;
  778. }
  779.  
  780. inline String operator + (const String& x, const SubString& y) 
  781. {
  782.   String r; cat(x, y, r); return r;
  783. }
  784.  
  785. inline String operator + (const String& x, const char* y) 
  786. {
  787.   String r; cat(x, y, r); return r;
  788. }
  789.  
  790. inline String operator + (const String& x, char y) 
  791. {
  792.   String r; cat(x, y, r); return r;
  793. }
  794.  
  795. inline String operator + (const SubString& x, const String& y) 
  796. {
  797.   String r; cat(x, y, r); return r;
  798. }
  799.  
  800. inline String operator + (const SubString& x, const SubString& y) 
  801. {
  802.   String r; cat(x, y, r); return r;
  803. }
  804.  
  805. inline String operator + (const SubString& x, const char* y) 
  806. {
  807.   String r; cat(x, y, r); return r;
  808. }
  809.  
  810. inline String operator + (const SubString& x, char y) 
  811. {
  812.   String r; cat(x, y, r); return r;
  813. }
  814.  
  815. inline String operator + (const char* x, const String& y) 
  816. {
  817.   String r; cat(x, y, r); return r;
  818. }
  819.  
  820. inline String operator + (const char* x, const SubString& y) 
  821. {
  822.   String r; cat(x, y, r); return r;
  823. }
  824.  
  825. inline String reverse(const String& x) 
  826. {
  827.   String r; r.rep = Sreverse(x.rep, r.rep); return r;
  828. }
  829.  
  830. inline String upcase(const String& x) 
  831. {
  832.   String r; r.rep = Supcase(x.rep, r.rep); return r;
  833. }
  834.  
  835. inline String downcase(const String& x) 
  836. {
  837.   String r; r.rep = Sdowncase(x.rep, r.rep); return r;
  838. }
  839.  
  840. inline String capitalize(const String& x) 
  841. {
  842.   String r; r.rep = Scapitalize(x.rep, r.rep); return r;
  843. }
  844.  
  845. #endif
  846.  
  847. // prepend
  848.  
  849. inline void String::prepend(const String& y)
  850. {
  851.   rep = Sprepend(rep, y.chars(), y.length());
  852. }
  853.  
  854. inline void String::prepend(const char* y)
  855. {
  856.   rep = Sprepend(rep, y, -1); 
  857. }
  858.  
  859. inline void String::prepend(char y)
  860. {
  861.   rep = Sprepend(rep, &y, 1); 
  862. }
  863.  
  864. inline void String::prepend(const SubString& y)
  865. {
  866.   rep = Sprepend(rep, y.chars(), y.length());
  867. }
  868.  
  869. // misc transformations
  870.  
  871.  
  872. inline void String::reverse()
  873. {
  874.   rep = Sreverse(rep, rep);
  875. }
  876.  
  877.  
  878. inline void String::upcase()
  879. {
  880.   rep = Supcase(rep, rep);
  881. }
  882.  
  883.  
  884. inline void String::downcase()
  885. {
  886.   rep = Sdowncase(rep, rep);
  887. }
  888.  
  889.  
  890. inline void String::capitalize()
  891. {
  892.   rep = Scapitalize(rep, rep);
  893. }
  894.  
  895. // element extraction
  896.  
  897. inline char&  String::operator [] (int i) 
  898. { 
  899.   if (((unsigned)i) >= length()) error("invalid index");
  900.   return rep->s[i];
  901. }
  902.  
  903. inline const char&  String::operator [] (int i) const
  904. { 
  905.   if (((unsigned)i) >= length()) error("invalid index");
  906.   return rep->s[i];
  907. }
  908.  
  909. inline char  String::elem (int i) const
  910. { 
  911.   if (((unsigned)i) >= length()) error("invalid index");
  912.   return rep->s[i];
  913. }
  914.  
  915. inline char  String::firstchar() const
  916. { 
  917.   return elem(0);
  918. }
  919.  
  920. inline char  String::lastchar() const
  921. { 
  922.   return elem(length() - 1);
  923. }
  924.  
  925. // searching
  926.  
  927. inline int String::index(char c, int startpos) const
  928. {
  929.   return search(startpos, length(), c);
  930. }
  931.  
  932. inline int String::index(const char* t, int startpos) const
  933. {   
  934.   return search(startpos, length(), t);
  935. }
  936.  
  937. inline int String::index(const String& y, int startpos) const
  938. {   
  939.   return search(startpos, length(), y.chars(), y.length());
  940. }
  941.  
  942. inline int String::index(const SubString& y, int startpos) const
  943. {   
  944.   return search(startpos, length(), y.chars(), y.length());
  945. }
  946.  
  947. inline int String::index(const Regex& r, int startpos) const
  948. {
  949.   int unused;  return r.search(chars(), length(), unused, startpos);
  950. }
  951.  
  952. inline int String::contains(char c) const
  953. {
  954.   return search(0, length(), c) >= 0;
  955. }
  956.  
  957. inline int String::contains(const char* t) const
  958. {   
  959.   return search(0, length(), t) >= 0;
  960. }
  961.  
  962. inline int String::contains(const String& y) const
  963. {   
  964.   return search(0, length(), y.chars(), y.length()) >= 0;
  965. }
  966.  
  967. inline int String::contains(const SubString& y) const
  968. {   
  969.   return search(0, length(), y.chars(), y.length()) >= 0;
  970. }
  971.  
  972. inline int String::contains(char c, int p) const
  973. {
  974.   return match(p, length(), 0, &c, 1) >= 0;
  975. }
  976.  
  977. inline int String::contains(const char* t, int p) const
  978. {
  979.   return match(p, length(), 0, t) >= 0;
  980. }
  981.  
  982. inline int String::contains(const String& y, int p) const
  983. {
  984.   return match(p, length(), 0, y.chars(), y.length()) >= 0;
  985. }
  986.  
  987. inline int String::contains(const SubString& y, int p) const
  988. {
  989.   return match(p, length(), 0, y.chars(), y.length()) >= 0;
  990. }
  991.  
  992. inline int String::contains(const Regex& r) const
  993. {
  994.   int unused;  return r.search(chars(), length(), unused, 0) >= 0;
  995. }
  996.  
  997. inline int String::contains(const Regex& r, int p) const
  998. {
  999.   return r.match(chars(), length(), p) >= 0;
  1000. }
  1001.  
  1002.  
  1003. inline int String::matches(const SubString& y, int p) const
  1004. {
  1005.   return match(p, length(), 1, y.chars(), y.length()) >= 0;
  1006. }
  1007.  
  1008. inline int String::matches(const String& y, int p) const
  1009. {
  1010.   return match(p, length(), 1, y.chars(), y.length()) >= 0;
  1011. }
  1012.  
  1013. inline int String::matches(const char* t, int p) const
  1014. {
  1015.   return match(p, length(), 1, t) >= 0;
  1016. }
  1017.  
  1018. inline int String::matches(char c, int p) const
  1019. {
  1020.   return match(p, length(), 1, &c, 1) >= 0;
  1021. }
  1022.  
  1023. inline int String::matches(const Regex& r, int p) const
  1024. {
  1025.   int l = (p < 0)? -p : length() - p;
  1026.   return r.match(chars(), length(), p) == l;
  1027. }
  1028.  
  1029.  
  1030. inline int SubString::contains(const char* t) const
  1031. {   
  1032.   return S.search(pos, pos+len, t) >= 0;
  1033. }
  1034.  
  1035. inline int SubString::contains(const String& y) const
  1036. {   
  1037.   return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
  1038. }
  1039.  
  1040. inline int SubString::contains(const SubString&  y) const
  1041. {   
  1042.   return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
  1043. }
  1044.  
  1045. inline int SubString::contains(char c) const
  1046. {
  1047.   return S.search(pos, pos+len, c) >= 0;
  1048. }
  1049.  
  1050. inline int SubString::contains(const Regex& r) const
  1051. {
  1052.   int unused;  return r.search(chars(), len, unused, 0) >= 0;
  1053. }
  1054.  
  1055. inline int SubString::matches(const Regex& r) const
  1056. {
  1057.   return r.match(chars(), len, 0) == len;
  1058. }
  1059.  
  1060.  
  1061. inline int String::gsub(const String& pat, const String& r)
  1062. {
  1063.   return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
  1064. }
  1065.  
  1066. inline int String::gsub(const SubString&  pat, const String& r)
  1067. {
  1068.   return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
  1069. }
  1070.  
  1071. inline int String::gsub(const Regex& pat, const String& r)
  1072. {
  1073.   return _gsub(pat, r.chars(), r.length());
  1074. }
  1075.  
  1076. inline int String::gsub(const char* pat, const String& r)
  1077. {
  1078.   return _gsub(pat, -1, r.chars(), r.length());
  1079. }
  1080.  
  1081. inline int String::gsub(const char* pat, const char* r)
  1082. {
  1083.   return _gsub(pat, -1, r, -1);
  1084. }
  1085.  
  1086.  
  1087.  
  1088. inline  ostream& operator<<(ostream& s, const String& x)
  1089. {
  1090.    s << x.chars(); return s;
  1091. }
  1092.  
  1093. // a zillion comparison operators
  1094.  
  1095. inline int operator==(const String& x, const String& y) 
  1096. {
  1097.   return compare(x, y) == 0; 
  1098. }
  1099.  
  1100. inline int operator!=(const String& x, const String& y)
  1101. {
  1102.   return compare(x, y) != 0; 
  1103. }
  1104.  
  1105. inline int operator>(const String& x, const String& y)
  1106. {
  1107.   return compare(x, y) > 0; 
  1108. }
  1109.  
  1110. inline int operator>=(const String& x, const String& y)
  1111. {
  1112.   return compare(x, y) >= 0; 
  1113. }
  1114.  
  1115. inline int operator<(const String& x, const String& y)
  1116. {
  1117.   return compare(x, y) < 0; 
  1118. }
  1119.  
  1120. inline int operator<=(const String& x, const String& y)
  1121. {
  1122.   return compare(x, y) <= 0; 
  1123. }
  1124.  
  1125. inline int operator==(const String& x, const SubString&  y) 
  1126. {
  1127.   return compare(x, y) == 0; 
  1128. }
  1129.  
  1130. inline int operator!=(const String& x, const SubString&  y)
  1131. {
  1132.   return compare(x, y) != 0; 
  1133. }
  1134.  
  1135. inline int operator>(const String& x, const SubString&  y)      
  1136. {
  1137.   return compare(x, y) > 0; 
  1138. }
  1139.  
  1140. inline int operator>=(const String& x, const SubString&  y)
  1141. {
  1142.   return compare(x, y) >= 0; 
  1143. }
  1144.  
  1145. inline int operator<(const String& x, const SubString&  y) 
  1146. {
  1147.   return compare(x, y) < 0; 
  1148. }
  1149.  
  1150. inline int operator<=(const String& x, const SubString&  y)
  1151. {
  1152.   return compare(x, y) <= 0; 
  1153. }
  1154.  
  1155. inline int operator==(const String& x, const char* t) 
  1156. {
  1157.   return compare(x, t) == 0; 
  1158. }
  1159.  
  1160. inline int operator!=(const String& x, const char* t) 
  1161. {
  1162.   return compare(x, t) != 0; 
  1163. }
  1164.  
  1165. inline int operator>(const String& x, const char* t)  
  1166. {
  1167.   return compare(x, t) > 0; 
  1168. }
  1169.  
  1170. inline int operator>=(const String& x, const char* t) 
  1171. {
  1172.   return compare(x, t) >= 0; 
  1173. }
  1174.  
  1175. inline int operator<(const String& x, const char* t)  
  1176. {
  1177.   return compare(x, t) < 0; 
  1178. }
  1179.  
  1180. inline int operator<=(const String& x, const char* t) 
  1181. {
  1182.   return compare(x, t) <= 0; 
  1183. }
  1184.  
  1185. inline int operator==(const SubString& x, const String& y) 
  1186. {
  1187.   return compare(y, x) == 0; 
  1188. }
  1189.  
  1190. inline int operator!=(const SubString& x, const String& y)
  1191. {
  1192.   return compare(y, x) != 0;
  1193. }
  1194.  
  1195. inline int operator>(const SubString& x, const String& y)      
  1196. {
  1197.   return compare(y, x) < 0;
  1198. }
  1199.  
  1200. inline int operator>=(const SubString& x, const String& y)     
  1201. {
  1202.   return compare(y, x) <= 0;
  1203. }
  1204.  
  1205. inline int operator<(const SubString& x, const String& y)      
  1206. {
  1207.   return compare(y, x) > 0;
  1208. }
  1209.  
  1210. inline int operator<=(const SubString& x, const String& y)     
  1211. {
  1212.   return compare(y, x) >= 0;
  1213. }
  1214.  
  1215. inline int operator==(const SubString& x, const SubString&  y) 
  1216. {
  1217.   return compare(x, y) == 0; 
  1218. }
  1219.  
  1220. inline int operator!=(const SubString& x, const SubString&  y)
  1221. {
  1222.   return compare(x, y) != 0;
  1223. }
  1224.  
  1225. inline int operator>(const SubString& x, const SubString&  y)      
  1226. {
  1227.   return compare(x, y) > 0;
  1228. }
  1229.  
  1230. inline int operator>=(const SubString& x, const SubString&  y)
  1231. {
  1232.   return compare(x, y) >= 0;
  1233. }
  1234.  
  1235. inline int operator<(const SubString& x, const SubString&  y) 
  1236. {
  1237.   return compare(x, y) < 0;
  1238. }
  1239.  
  1240. inline int operator<=(const SubString& x, const SubString&  y)
  1241. {
  1242.   return compare(x, y) <= 0;
  1243. }
  1244.  
  1245. inline int operator==(const SubString& x, const char* t) 
  1246. {
  1247.   return compare(x, t) == 0; 
  1248. }
  1249.  
  1250. inline int operator!=(const SubString& x, const char* t) 
  1251. {
  1252.   return compare(x, t) != 0;
  1253. }
  1254.  
  1255. inline int operator>(const SubString& x, const char* t)  
  1256. {
  1257.   return compare(x, t) > 0; 
  1258. }
  1259.  
  1260. inline int operator>=(const SubString& x, const char* t) 
  1261. {
  1262.   return compare(x, t) >= 0; 
  1263. }
  1264.  
  1265. inline int operator<(const SubString& x, const char* t)  
  1266. {
  1267.   return compare(x, t) < 0; 
  1268. }
  1269.  
  1270. inline int operator<=(const SubString& x, const char* t) 
  1271. {
  1272.   return compare(x, t) <= 0; 
  1273. }
  1274.  
  1275.  
  1276. // a helper needed by at, before, etc.
  1277.  
  1278. inline SubString String::_substr(int first, int l)
  1279. {
  1280.   if (first < 0 || (unsigned)(first + l) > length() )
  1281.     return SubString(_nilString, 0, 0) ;
  1282.   else 
  1283.     return SubString(*this, first, l);
  1284. }
  1285.  
  1286. #endif
  1287.